home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 1996 November: Tool Chest / Dev.CD Nov 96 TC / Dev.CD Nov 96 TC.toast / Sample Code / Interapplication Communication / MenuScripter 4.0 / Sources / MSUtils.c < prev    next >
Encoding:
Text File  |  1996-07-09  |  15.0 KB  |  638 lines  |  [TEXT/CWIE]
  1. // MSUtils.c
  2. //
  3. // Original version by Jon Lansdell and Nigel Humphreys.
  4. // 4.0 and 3.1 updates by Greg Sutton.
  5. // ©Apple Computer Inc 1996, all rights reserved.
  6.  
  7. /*
  8.     Changes for 3.1:
  9.     
  10.         12-Oct-95    : CW : Simplified FeatureIsImplemented routine.
  11.                            Added init of gHasDragManager flag in CheckEnvironment.
  12.                            
  13.     Changes for 4.0:
  14.         17-Apr-96    : GS : Changed pascal calling conventions to C where possible.
  15.                            Changed behavior of outlining Up, Down and Other in Size menu.
  16.  
  17. */
  18.  
  19.  
  20. #ifdef THINK_C
  21.     #include "PLStrs.h"
  22. #else
  23.     #include <PLStringFuncs.h>
  24. #endif
  25. #include <Events.h>
  26. #include <Traps.h>
  27. #include <Dialogs.h>
  28. #include <Fonts.h>
  29. #include <Packages.h>
  30. #include <ToolUtils.h>
  31. #include <AppleEvents.h>
  32. #include <CodeFragments.h>
  33. #include "MSUtils.h"
  34.  
  35. //        Name:             LesserOf
  36. //        Purpose:        Returns the Lesser of two longints.
  37.  
  38. #pragma segment Utils
  39.         
  40. long    LesserOf( long A, long B )
  41. {
  42.     if ( A < B )
  43.         return( A );
  44.     else
  45.         return( B );
  46. } // LesserOf
  47.             
  48.  
  49. //        Name:             GreaterOf
  50. //        Purpose:        Returns the Greater of two longints.
  51.     
  52. #pragma segment Utils
  53.         
  54. long    GreaterOf( long A, long B )
  55. {
  56.     if ( A > B )
  57.         return(A);
  58.     else
  59.         return(B);
  60. } // GreaterOf
  61.             
  62.  
  63. //        Name:         ShowError
  64. //        Purpose:    Reports an error to the user as both string and number.
  65.  
  66. #pragma segment Utils
  67.         
  68. void    ShowError( Str255 theError, long theErrorCode )
  69. {
  70.     short     alertResult;
  71.     Str255    theString;
  72.     OSErr     myErr;
  73.      
  74.     myErr = AEInteractWithUser( kAEDefaultTimeout, nil, nil );
  75.      
  76.     if (myErr == noErr)
  77.     {
  78.         SetCursor(&qd.arrow);
  79.         NumToString(theErrorCode, theString);
  80.         ParamText( theError, theString, (unsigned char *)"", (unsigned char *)"" );
  81.         alertResult = Alert(300, nil);
  82.     }
  83. } // ShowError
  84.  
  85.  
  86. //        Name:             Ours
  87. //        Purpose:        Checks the frontmost window belongs to the app.
  88.  
  89. #pragma segment Utils        
  90.  
  91. Boolean    Ours( WindowPtr aWindow )
  92. {
  93.     if (aWindow)
  94.         if (((WindowPeek)aWindow)->windowKind == zoomDocProc)
  95.             return(true);
  96.  
  97.     return(false);
  98. } // Ours
  99.  
  100.  
  101. //        Name:             SetShortMenus
  102. //        Purpose:        Cuts the menus down to a minimum - Apple File Edit.
  103. //                        Greys out the unavailable options - used when no docs open
  104.  
  105. #pragma segment Utils        
  106.  
  107. void    SetShortMenus( void )
  108. { 
  109.     DeleteMenu(mfontID);
  110.     DeleteMenu(sizeID);
  111.     DeleteMenu(styleID);
  112.     DeleteMenu(mscriptID);
  113.     DeleteMenu(subroutineID);
  114.  
  115.     SetMenuItemState ( false, myMenus[fileM], fmClose);
  116.     SetMenuItemState ( false, myMenus[fileM], fmSave);
  117.     SetMenuItemState ( false, myMenus[fileM], fmSaveAs);
  118.     SetMenuItemState ( false, myMenus[fileM], fmRevert);
  119.     SetMenuItemState ( false, myMenus[fileM], fmPageSetUp);
  120.  
  121.     if (gGXIsPresent)
  122.     {
  123.         SetMenuItemState ( false, myMenus[fileM], fmPrint);
  124.         SetMenuItemState ( false, myMenus[fileM], fmPrintOne );
  125.     }
  126.     else
  127.         SetMenuItemState ( false, myMenus[fileM], fmNoGXPrint);
  128.  
  129.     // now the unnecessary items on the edit menu
  130.                 
  131.     SetMenuItemState ( false, myMenus[editM], undoCommand);
  132.     SetMenuItemState ( false, myMenus[editM], cutCommand);
  133.     SetMenuItemState ( false, myMenus[editM], copyCommand);
  134.     SetMenuItemState ( false, myMenus[editM], clearCommand);
  135.     SetMenuItemState ( false, myMenus[editM], pasteCommand);
  136.     SetMenuItemState ( false, myMenus[editM], selectAllCommand);
  137.  
  138.     DrawMenuBar();
  139. }  // SetShortMenus
  140.  
  141.  
  142. //        Name:         SetLongMenus
  143. //        Purpose:    Reinstates the full menu bar - called when first document
  144. //                     opened.
  145.  
  146. #pragma segment Utils        
  147.  
  148. void    SetLongMenus( void )
  149. {
  150.     InsertMenu(myMenus[fontM], 0);
  151.     InsertMenu(myMenus[sizeM], 0);
  152.     InsertMenu(myMenus[styleM], 0);
  153.     InsertMenu(myMenus[scriptM], 0);
  154.     InsertMenu(myMenus[subroutineM], 0);
  155.  
  156.     SetMenuItemState ( true, myMenus[fileM], fmClose);
  157.     SetMenuItemState ( true, myMenus[fileM], fmSave);
  158.     SetMenuItemState ( true, myMenus[fileM], fmSaveAs);
  159.     SetMenuItemState ( true, myMenus[fileM], fmRevert);
  160.     SetMenuItemState ( true, myMenus[fileM], fmPageSetUp);
  161.  
  162.     if (gGXIsPresent)
  163.     {
  164.         SetMenuItemState ( true, myMenus[fileM],  fmPrint );
  165.         SetMenuItemState ( true, myMenus[fileM],  fmPrintOne );
  166.     }
  167.     else
  168.         SetMenuItemState ( true, myMenus[fileM], fmNoGXPrint );
  169.  
  170.     // now the necessary items on the edit menu -
  171.     //    many other items fixed on each pass thru the main event
  172.     //    loop or before the window pulled down
  173.     
  174.     SetMenuItemState ( true, myMenus[editM], selectAllCommand);
  175.  
  176.     DrawMenuBar();
  177. }  // SetLongMenus
  178.  
  179.  
  180. //        Name:         SetStyleMenu
  181. //        Purpose:    Sets the style menu checking to reflect the style of the
  182. //                     first character of the current selection in the given
  183. //                     document.
  184.  
  185. #pragma segment Utils        
  186.         
  187. void    SetStyleMenu( DPtr theDoc )
  188. {
  189.     TextStyle    theTStyle;
  190.     short       contMode;
  191.     short       i;
  192.     
  193.     contMode = doFace;
  194.     
  195.     TEContinuousStyle(&contMode,&theTStyle,theDoc->theText);
  196.     
  197.     if ((contMode & doFace) != 0)
  198.     {
  199.         CheckItem(myMenus[styleM], cPlain,     (theTStyle.tsFace == 0));
  200.         CheckItem(myMenus[styleM], cBold,      (bold      & theTStyle.tsFace));
  201.         CheckItem(myMenus[styleM], cItalic,    (italic    & theTStyle.tsFace));
  202.         CheckItem(myMenus[styleM], cUnderline, (underline & theTStyle.tsFace));
  203.         CheckItem(myMenus[styleM], cOutline,   (outline   & theTStyle.tsFace));
  204.         CheckItem(myMenus[styleM], cShadow,    (shadow    & theTStyle.tsFace));
  205.         CheckItem(myMenus[styleM], cCondense,  (condense  & theTStyle.tsFace));
  206.         CheckItem(myMenus[styleM], cExtend,    (extend    & theTStyle.tsFace));
  207.     }
  208.     else
  209.         for (i=cPlain; i<= cExtend; i++)
  210.             CheckItem(myMenus[styleM], i, false);
  211. }
  212.  
  213.  
  214. //    Name:       SetSizeMenu
  215. //    Purpose:    Outline all the items if the current font is an
  216. //                outline font. Check the size of the current selection
  217.  
  218. #pragma segment Utils        
  219.  
  220. void    SetSizeMenu( DPtr theDoc )
  221. {
  222.     short         i;
  223.     short        aSize;
  224.     short        max;
  225.     long         theSize;
  226.     Str255        name;
  227.     Boolean       sizeinMenu;
  228.     Point         numer;
  229.     TextStyle    theStyle;
  230.     TEHandle    myText;
  231.     short       contMode;
  232.     
  233.     numer.h = 1;
  234.     numer.v = 1;
  235.     
  236.     myText = theDoc->theText;
  237.     
  238.     contMode = doSize+doFont;
  239.     
  240.     TEContinuousStyle( &contMode, &theStyle, theDoc->theText );
  241.     
  242.     sizeinMenu = false;
  243.     max = CountMItems(myMenus[sizeM]);
  244.     for (i = 1; i <= max - 5; i++)
  245.     {
  246.         GetItem(myMenus[sizeM], i, name);
  247.         StringToNum(name, &theSize);
  248.         aSize = (short)theSize;
  249.  
  250.         if (RealFont(theStyle.tsFont, aSize) && (contMode & doFont) != 0) // there is only one font and this size exists
  251.             SetItemStyle(myMenus[sizeM], i, outline);
  252.         else
  253.             SetItemStyle(myMenus[sizeM], i, 0);
  254.  
  255.         if ((aSize == theStyle.tsSize) && (contMode & doSize) != 0)
  256.         {
  257.             sizeinMenu = true;
  258.             CheckItem(myMenus[sizeM], i, true);
  259.         }
  260.         else
  261.             CheckItem(myMenus[sizeM], i, false);
  262.     }
  263.     
  264.     // If it's not a size in the menu,and there is only one size in the
  265.     //  selection range check the other item
  266.     
  267.     if (! sizeinMenu && (contMode & doSize) != 0)
  268.     {
  269.         CheckItem(myMenus[sizeM], max, true);
  270.  
  271.         if ( RealFont(theStyle.tsFont, theStyle.tsSize ) && (contMode & doFont) != 0 )
  272.             SetItemStyle(myMenus[sizeM], max, outline);
  273.         else
  274.             SetItemStyle(myMenus[sizeM], max, 0);
  275.     }
  276.     else
  277.     {
  278.         CheckItem(myMenus[sizeM], max, false);
  279.         SetItemStyle(myMenus[sizeM], max, 0);
  280.     }
  281.  
  282.         // Outline Up if next size up is available
  283.     if ( RealFont(theStyle.tsFont, theStyle.tsSize + 1 ) && (contMode & doFont) != 0 )
  284.         SetItemStyle(myMenus[sizeM], max - 3, outline);
  285.     else
  286.         SetItemStyle(myMenus[sizeM], max - 3, 0);
  287.  
  288.         // Outline Down if next size up is available
  289.     if ( RealFont(theStyle.tsFont, theStyle.tsSize - 1 ) && (contMode & doFont) != 0 )
  290.         SetItemStyle(myMenus[sizeM], max - 2, outline);
  291.     else
  292.         SetItemStyle(myMenus[sizeM], max - 2, 0);
  293. }
  294.  
  295.  
  296. //    Name:       SetFontMenu
  297. //    Purpose:    Set the font menu according to the state of
  298. //                                current selection of the supplied document.
  299.  
  300. #pragma segment Utils
  301.         
  302. void    SetFontMenu( DPtr theDoc )
  303. {
  304.     MenuHandle        theMHandle;
  305.     short            theNumber;
  306.     short            i;
  307.     short            max;
  308.     Str255            name;
  309.     TextStyle        theStyle;
  310.     short            contMode;
  311.     
  312.     theMHandle = GetMHandle(mfontID);
  313.     
  314.     if (gFontMItem)
  315.     CheckItem(theMHandle, gFontMItem, false);
  316.         
  317.     max = CountMItems(theMHandle);
  318.     
  319.     contMode = doFont;
  320.     TEContinuousStyle(&contMode,&theStyle,theDoc->theText);
  321.     
  322.     gFontMItem = 0;
  323.     
  324.     if (contMode & doFont)
  325.         for (i=1; i<=max; i++)
  326.         {
  327.             GetItem(theMHandle, i, name);
  328.             GetFNum(name, &theNumber);
  329.             if (theNumber == theStyle.tsFont)
  330.                 gFontMItem = i;
  331.         }
  332.     
  333.     if (gFontMItem)
  334.         CheckItem(theMHandle, gFontMItem, true);
  335.         
  336.     SetSizeMenu(theDoc);
  337.     SetStyleMenu(theDoc);
  338. }
  339.  
  340.  
  341. //    Name:       GetTempFileName
  342. //    Purpose:    Fills newstring with a temporary file name.
  343.  
  344. #pragma segment Utils
  345.  
  346. void    GetTempFileName( DPtr aDoc, Str255 newString )
  347. {
  348.     Str255        s;
  349.     Str255        fileName;
  350.     
  351.     if (aDoc->everSaved == false)
  352.         PLstrcpy(fileName, (unsigned char *)"\pTEXTra");
  353.     else
  354.         PLstrcpy(fileName, aDoc->theFileName);
  355.     
  356.     // generate a unique(ish) temporary filename
  357.     
  358.     if (fileName[0] > 21)
  359.       fileName[0] = 21;
  360.             
  361.     NumToString(TickCount(), s);
  362.     
  363.     PLstrcat(fileName, s);
  364.     
  365.     PLstrcpy(newString,fileName);
  366. }
  367.  
  368.  
  369. //    Name:       SetText
  370. //    Purpose:    Sets the text of the supplied itemNo in aDialog to 
  371. //                                theString and select it.
  372.  
  373. #pragma segment Utils
  374.  
  375. void    SetText( DialogPtr aDialog, short itemNo, Str255 theString )
  376. {
  377.     Handle      itemHandle;
  378.     Rect        box;
  379.     short       kind;
  380.     TEHandle    theTEHandle;
  381.     
  382.     GetDItem(aDialog, itemNo, &kind, &itemHandle, &box);
  383.     SetIText(itemHandle, theString);
  384.     
  385.     theTEHandle = ((DialogPeek)aDialog)->textH;
  386.     
  387.     // Set all the text to be selected
  388.     if (theTEHandle)
  389.         TESetSelect(0, 255, theTEHandle);
  390. }
  391.             
  392.  
  393. //    Name:       RetrieveText
  394. //    Purpose:    Returns the text of anItem in aDialog in aString.
  395.  
  396. #pragma segment Utils
  397.  
  398. void    RetrieveText( DialogPtr aDialog, short anItem, Str255 aString )
  399. {
  400.     short      kind;
  401.     Rect       box;
  402.     Handle     itemHandle;
  403.     
  404.     GetDItem(aDialog, anItem, &kind, &itemHandle, &box);
  405.     GetIText(itemHandle, aString);
  406. }
  407.  
  408.  
  409. //    Name:       DrawDefaultOutline
  410. //    Purpose:    Draws an outline around theItem.
  411. //                    Called as a useritem Proc by the dialog manager.
  412. //                    To use place a useritem over the default item in the
  413. //                    dialog and install the address of this proc as the item
  414. //                    handle.
  415.  
  416. #pragma segment Utils
  417.  
  418. pascal void    DrawDefaultOutline( DialogPtr theDialog, short theItem )
  419. {
  420.     short       kind;
  421.     Handle      itemHandle;
  422.     Rect        box;
  423.             
  424.     GetDItem(theDialog, theItem, &kind, &itemHandle, &box);
  425.     PenSize(3, 3);
  426.     InsetRect(&box, - 4, - 4);
  427.     FrameRoundRect(&box, 16, 16);
  428.     PenNormal();
  429. } // DrawDefaultOutline
  430.             
  431.  
  432. //    Name:       AdornDefaultButton
  433. //    Purpose:    Installs DrawDefaultOutline as the useritem proc
  434. //                    for the given item.
  435.  
  436. #pragma segment Utils
  437.         
  438. void    AdornDefaultButton(DialogPtr theDialog,short theItem)
  439. {
  440.     short       kind;
  441.     Handle      itemHandle;
  442.     Rect        box;
  443.     
  444.     GetDItem(theDialog, theItem, &kind, &itemHandle, &box);
  445.     SetDItem(theDialog, theItem, kind, (Handle)gDefaultButtonUPP, &box);
  446. }
  447.  
  448. void    GetRectOfDialogItem( DialogPtr theDialog, short theItem, Rect *theRect )
  449. {
  450.     short       kind;
  451.     Handle      itemHandle;
  452.     
  453.     GetDItem(theDialog, theItem, &kind, &itemHandle, theRect);
  454. }
  455.  
  456. // -------  Determining of Gestalt is available -------
  457. // The following routines come from the Inside Mac VI recommendations
  458. //  about how to find if a trap is available
  459.  
  460. //    The glue for Gestalt will be in MPW 3.2, so if it is available we will also
  461. //   need to check the system version
  462.  
  463. #pragma segment Utils
  464.  
  465. short    NumToolboxTraps(void)
  466. {
  467.     if (NGetTrapAddress(_InitGraf, ToolTrap) == NGetTrapAddress(0xAA6E, ToolTrap))
  468.         return(0x200);
  469.     else
  470.         return(0x400);
  471. }
  472.  
  473. #pragma segment Utils
  474.  
  475. #define TrapMask  0x0800
  476.  
  477. TrapType    GetTrapType(short theTrap)
  478. {
  479.     if ((theTrap & TrapMask) > 0)
  480.         return(ToolTrap);
  481.     else
  482.         return(OSTrap);
  483. }
  484.  
  485. #pragma segment Utils
  486.  
  487. Boolean    TrapAvailable(short theTrap)
  488. {
  489.     TrapType  tType;
  490.     
  491.     tType = GetTrapType(theTrap);
  492.     if (tType == ToolTrap)
  493.     {
  494.         theTrap = theTrap & 0x07FF;
  495.         if (theTrap >= NumToolboxTraps())
  496.             theTrap = _Unimplemented;
  497.     }
  498.  
  499.     return(NGetTrapAddress(theTrap, tType) != NGetTrapAddress(_Unimplemented,ToolTrap));
  500. }
  501.  
  502. #pragma segment Utils
  503.  
  504. #define _Gestalt 0xA1AD
  505.  
  506. Boolean    GestaltAvailable( void )
  507. {
  508.     return(TrapAvailable(_Gestalt));
  509. }
  510.  
  511.  
  512. // ------ FeatureIsImplemented ------
  513. // This is called to use Gestalt to determine if a feature is implemented.
  514. // This applies to only those referenced by OSType.
  515.  
  516. #pragma segment Utils
  517.  
  518. Boolean FeatureIsImplemented( OSType theFeature, short theTestBit )
  519. {
  520.     OSErr     err;
  521.     long      result;
  522.  
  523.     err = Gestalt ( theFeature, &result );
  524.     return (err == noErr && (result & (1L << theTestBit)));
  525. }
  526.  
  527.  
  528. #pragma segment Utils
  529.  
  530. Boolean    CheckEnvironment( void )
  531. {
  532.     long        response;
  533.  
  534.         // first determine of Gestalt is available- if it isn't exit
  535.         // as we only run under 7.0.  It could it present in 6.04 - so we need
  536.         // to do some further checks for important features
  537.     gGestaltAvailable = GestaltAvailable();
  538.     
  539.     if (!gGestaltAvailable)
  540.         return(false);
  541.  
  542.         // check if the Edition Manager is present
  543.     gEditionManagerImplemented = FeatureIsImplemented(gestaltEditionMgrAttr, gestaltEditionMgrPresent);
  544.  
  545.         // and for good measure - the Alias manager
  546.     gAliasManagerImplemented  = FeatureIsImplemented(gestaltAliasMgrAttr, gestaltAliasMgrPresent);
  547.  
  548.         // check for the AppleEvents manager - we certainly can't work without it
  549.     gAppleEventsImplemented   = FeatureIsImplemented(gestaltAppleEventsAttr, gestaltAppleEventsPresent);
  550.  
  551.         // check if recording is implemented
  552.     gRecordingImplemented   = FeatureIsImplemented(gestaltAppleEventsAttr,1);
  553.         
  554.         // check for the Outline fonts
  555.     gOutlineFontsImplemented  = FeatureIsImplemented(gestaltFontMgrAttr, gestaltOutlineFonts);
  556.     
  557.         // We would also like the Drag Manager
  558.     gHasDragManager = FeatureIsImplemented ( gestaltDragMgrAttr, gestaltDragMgrPresent );
  559.  
  560. // It isn't enough to use Gestalt because we may not have sucessfully linked
  561. // to the DragLib shared library. So, we also need to test one of the symbols
  562. // against kUnresolvedSymbol to make sure we have a valid connection to it.
  563.  
  564. #if GENERATINGCFM
  565.     if ( gHasDragManager )
  566.         gHasDragManager = (InstallTrackingHandler != (void*) kUnresolvedSymbolAddress);
  567. #endif
  568.     
  569.         // Want the process manager
  570.     gHasProcessManager = ( noErr == Gestalt( gestaltOSAttr, &response ) );
  571.  
  572.  
  573.     return (gEditionManagerImplemented
  574.                 && gAliasManagerImplemented 
  575.                     && gAppleEventsImplemented
  576.                         && gOutlineFontsImplemented
  577.                             && gHasProcessManager );
  578.                             
  579. }  // CheckEnvironment
  580.             
  581.  
  582. //    DoPageSetup returns true if the page setup of the document is altered
  583.     
  584. Boolean    DoPageSetup(DPtr theDoc)
  585. {
  586.     Boolean result = false;
  587.     
  588.     if ( ! gGXIsPresent )
  589.         if ( theDoc )
  590.         {
  591.             PrOpen();
  592.             result =  PrStlDialog(theDoc->thePrintSetup);
  593.             PrClose();
  594.         }
  595.         
  596.     return(result);
  597. }  // DoPageSetup
  598.  
  599.  
  600. //    Name:    CtrlKeyPressed
  601. //    Purpose: Returns true if control key pressed during event
  602.  
  603. Boolean    CtrlKeyPressed( const EventRecord *theEvent )
  604. {
  605.     return((theEvent->modifiers & controlKey) != 0);
  606. }
  607.     
  608.  
  609. //    Name:    OptionKeyPressed
  610. //    Purpose: Returns true if option key pressed during event
  611.  
  612. Boolean    OptionKeyPressed( const EventRecord *theEvent )
  613. {
  614.     return((theEvent->modifiers & optionKey) != 0);
  615. }
  616.  
  617.  
  618. Boolean SetMenuItemState (  Boolean    theState,
  619.                             MenuHandle theMenu,
  620.                             short      item )
  621. {
  622.     Boolean reDrawMenuBar = false;
  623.     Boolean isSet;
  624.     
  625.     if (item == kMenuTitle)
  626.     {
  627.         isSet = ((*theMenu)->enableFlags & 0x00000001);
  628.         reDrawMenuBar = (isSet != theState);
  629.     }
  630.  
  631.     if (theState)
  632.         EnableItem ( theMenu, item );
  633.     else
  634.         DisableItem ( theMenu, item );
  635.     
  636.     return ( reDrawMenuBar );
  637. }
  638.